package com.zhentao.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zhentao.mapper.*;
import com.zhentao.pojo.*;
import com.zhentao.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @author lenovo
 * @description 针对表【product(商品表)】的数据库操作Service实现
 * @createDate 2025-08-29 09:27:34
 */
@Service
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product>
        implements ProductService {

    @Autowired
    private ProductImageMapper productImageMapper;
    @Autowired
    private ProductMapper productMapper;

    @Override
    public List<Product> getRecommendProduct() {
        // 获取商品平均评分前20的商品
        List<Product> products = productMapper.selectList(new QueryWrapper<Product>().orderByDesc("avg_score").last("Limit 20"));
        // 2. 批量获取所有商品的图片
        extracted(products);
        return products;
    }

    @Override
    public Page<Product> getProductList(Integer level2Id, Integer sort, Integer pageNum, Integer pageSize) {
        QueryWrapper<Product> wrapper = new QueryWrapper<>();
        wrapper.eq(level2Id != null, "level2_id", level2Id);

        // 根据排序类型设置排序规则
        if (sort == null || sort == 0) {
            // 综合排序：综合考虑销量、评分、价格等因素
            // 使用加权计算：销量权重40% + 评分权重40% + 价格权重20%（价格越低越好，所以用除法）
            wrapper.orderByDesc("(sales_count * 0.4 + avg_score * 20 * 0.4 + (1000 / GREATEST(price, 1)) * 0.2)");
        } else if (sort == 1) {
            // 销量排序：按销量倒序
            wrapper.orderByDesc("sales_count");
        } else if (sort == 2) {
            // 评分排序：按评分倒序
            wrapper.orderByDesc("avg_score");
        } else if (sort == 3) {
            // 价格排序：按价格倒序（高价优先）
            wrapper.orderByDesc("price");
        }

        // 添加二级排序，避免相同值时顺序不稳定
        wrapper.orderByDesc("create_time");

        // 1. 查询所有商品
        Page<Product> products = productMapper.selectPage(new Page<>(pageNum, pageSize), wrapper);

        // 2. 批量获取所有商品的图片
        extracted(products.getRecords());
        return products;
    }

    @Override
    public Product getProductDetail(Integer productId) {
        Product product = productMapper.selectById(productId);
        if (product != null) {
            // 获取商品图片
            List<ProductImage> allProductImages = productImageMapper.selectList(new QueryWrapper<ProductImage>().eq("product_id", productId).in("type", Arrays.asList(0, 1)));

            Map<Integer, List<String>> imagesByType = allProductImages.stream()
                    .collect(Collectors.groupingBy(ProductImage::getType,
                            Collectors.mapping(ProductImage::getImageUrl, Collectors.toList())));
            // 轮播图
            List<String> type0Images = imagesByType.getOrDefault(0, Collections.emptyList());
            product.setPic(type0Images);
            // 详情图
            List<String> type1Images = imagesByType.getOrDefault(1, Collections.emptyList());
            product.setPic2(type1Images);
        }
        return product;
    }

    @Override
    public List<Product> getRecommendProducts(Integer level2Id) {
        QueryWrapper<Product> wrapper = new QueryWrapper<>();
        wrapper.eq(level2Id != null, "level2_id", level2Id);
        // 综合排序：综合考虑销量、评分、价格等因素
        // 使用加权计算：销量权重40% + 评分权重40% + 价格权重20%（价格越低越好，所以用除法）
        wrapper.orderByDesc("(sales_count * 0.4 + avg_score * 20 * 0.4 + (1000 / GREATEST(price, 1)) * 0.2)");
        // 添加二级排序，避免相同值时顺序不稳定
        wrapper.orderByDesc("create_time");
        wrapper.last("Limit 6");
        List<Product> products = list(wrapper);
        extracted(products);
        return products;
    }

    // 批量获取所有商品的图片
    private void extracted(List<Product> products) {
        if (!products.isEmpty()) {
            List<Long> productIds = products.stream().map(Product::getProductId).toList();
            // 查询每个商品的第一张图片（按sort_order排序）
            List<ProductImage> productImages = productImageMapper.selectList(
                    new QueryWrapper<ProductImage>()
                            .in("product_id", productIds)
                            .eq("sort_order", 1));

            // 按商品ID分组图片，每个商品ID对应其第一张图片，处理重复键的情况
            Map<Long, ProductImage> imageByProduct = productImages.stream()
                    .collect(Collectors.toMap(ProductImage::getProductId,
                            image -> image,
                            (existing, replacement) -> existing));

            // 为每个商品设置图片列表（只包含一张图片）
            for (Product product : products) {
                ProductImage image = imageByProduct.get(product.getProductId());
                if (image != null) {
                    product.setPic(Collections.singletonList(image.getImageUrl()));
                } else {
                    product.setPic(Collections.emptyList());
                }
            }
        }
    }
}




